home *** CD-ROM | disk | FTP | other *** search
/ Enter 2006 September / Enter 09 2006.iso / Internet / SpamExperts Home 1.1 / SpamExperts Home.exe / lib / spamexperts.modules / asyncore.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-07-14  |  15.0 KB  |  582 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Basic infrastructure for asynchronous socket service clients and servers.
  5.  
  6. There are only two ways to have a program on a single processor do "more
  7. than one thing at a time".  Multi-threaded programming is the simplest and
  8. most popular way to do it, but there is another very different technique,
  9. that lets you have nearly all the advantages of multi-threading, without
  10. actually using multiple threads. it\'s really only practical if your program
  11. is largely I/O bound. If your program is CPU bound, then pre-emptive
  12. scheduled threads are probably what you really need. Network servers are
  13. rarely CPU-bound, however.
  14.  
  15. If your operating system supports the select() system call in its I/O
  16. library (and nearly all do), then you can use it to juggle multiple
  17. communication channels at once; doing other work while your I/O is taking
  18. place in the "background."  Although this strategy can seem strange and
  19. complex, especially at first, it is in many ways easier to understand and
  20. control than multi-threaded programming. The module documented here solves
  21. many of the difficult problems for you, making the task of building
  22. sophisticated high-performance network servers and clients a snap.
  23. '''
  24. import exceptions
  25. import select
  26. import socket
  27. import sys
  28. import time
  29. import os
  30. from errno import EALREADY, EINPROGRESS, EWOULDBLOCK, ECONNRESET, ENOTCONN, ESHUTDOWN, EINTR, EISCONN, errorcode
  31.  
  32. try:
  33.     socket_map
  34. except NameError:
  35.     socket_map = { }
  36.  
  37.  
  38. class ExitNow(exceptions.Exception):
  39.     pass
  40.  
  41.  
  42. def read(obj):
  43.     
  44.     try:
  45.         obj.handle_read_event()
  46.     except ExitNow:
  47.         raise 
  48.     except:
  49.         obj.handle_error()
  50.  
  51.  
  52.  
  53. def write(obj):
  54.     
  55.     try:
  56.         obj.handle_write_event()
  57.     except ExitNow:
  58.         raise 
  59.     except:
  60.         obj.handle_error()
  61.  
  62.  
  63.  
  64. def _exception(obj):
  65.     
  66.     try:
  67.         obj.handle_expt_event()
  68.     except ExitNow:
  69.         raise 
  70.     except:
  71.         obj.handle_error()
  72.  
  73.  
  74.  
  75. def readwrite(obj, flags):
  76.     
  77.     try:
  78.         if flags & (select.POLLIN | select.POLLPRI):
  79.             obj.handle_read_event()
  80.         
  81.         if flags & select.POLLOUT:
  82.             obj.handle_write_event()
  83.         
  84.         if flags & (select.POLLERR | select.POLLHUP | select.POLLNVAL):
  85.             obj.handle_expt_event()
  86.     except ExitNow:
  87.         raise 
  88.     except:
  89.         obj.handle_error()
  90.  
  91.  
  92.  
  93. def poll(timeout = 0.0, map = None):
  94.     if map is None:
  95.         map = socket_map
  96.     
  97.     if map:
  98.         r = []
  99.         w = []
  100.         e = []
  101.         for fd, obj in map.items():
  102.             is_r = obj.readable()
  103.             is_w = obj.writable()
  104.             if is_r:
  105.                 r.append(fd)
  106.             
  107.             if is_w:
  108.                 w.append(fd)
  109.             
  110.             if is_r or is_w:
  111.                 e.append(fd)
  112.                 continue
  113.         
  114.         if r == r and w == w:
  115.             pass
  116.         elif w == e:
  117.             time.sleep(timeout)
  118.         else:
  119.             
  120.             try:
  121.                 (r, w, e) = select.select(r, w, e, timeout)
  122.             except select.error:
  123.                 []
  124.                 err = []
  125.                 if err[0] != EINTR:
  126.                     raise 
  127.                 else:
  128.                     return None
  129.             except:
  130.                 err[0] != EINTR
  131.  
  132.         for fd in r:
  133.             obj = map.get(fd)
  134.             read(obj)
  135.         
  136.         for fd in w:
  137.             obj = map.get(fd)
  138.             if obj is None:
  139.                 continue
  140.             
  141.             write(obj)
  142.         
  143.         for fd in e:
  144.             obj = map.get(fd)
  145.             if obj is None:
  146.                 continue
  147.             
  148.             _exception(obj)
  149.         
  150.     
  151.  
  152.  
  153. def poll2(timeout = 0.0, map = None):
  154.     if map is None:
  155.         map = socket_map
  156.     
  157.     if timeout is not None:
  158.         timeout = int(timeout * 1000)
  159.     
  160.     pollster = select.poll()
  161.     if map:
  162.         for fd, obj in map.items():
  163.             flags = 0
  164.             if obj.readable():
  165.                 flags |= select.POLLIN | select.POLLPRI
  166.             
  167.             if obj.writable():
  168.                 flags |= select.POLLOUT
  169.             
  170.             if flags:
  171.                 flags |= select.POLLERR | select.POLLHUP | select.POLLNVAL
  172.                 pollster.register(fd, flags)
  173.                 continue
  174.         
  175.         
  176.         try:
  177.             r = pollster.poll(timeout)
  178.         except select.error:
  179.             err = None
  180.             if err[0] != EINTR:
  181.                 raise 
  182.             
  183.             r = []
  184.  
  185.         for fd, flags in r:
  186.             obj = map.get(fd)
  187.             if obj is None:
  188.                 continue
  189.             
  190.             readwrite(obj, flags)
  191.         
  192.     
  193.  
  194. poll3 = poll2
  195.  
  196. def loop(timeout = 30.0, use_poll = False, map = None, count = None):
  197.     if map is None:
  198.         map = socket_map
  199.     
  200.     if use_poll and hasattr(select, 'poll'):
  201.         poll_fun = poll2
  202.     else:
  203.         poll_fun = poll
  204.     if count is None:
  205.         while map:
  206.             poll_fun(timeout, map)
  207.     else:
  208.         while map and count > 0:
  209.             poll_fun(timeout, map)
  210.             count = count - 1
  211.  
  212.  
  213. class dispatcher:
  214.     debug = False
  215.     connected = False
  216.     accepting = False
  217.     closing = False
  218.     addr = None
  219.     
  220.     def __init__(self, sock = None, map = None):
  221.         if map is None:
  222.             self._map = socket_map
  223.         else:
  224.             self._map = map
  225.         if sock:
  226.             self.set_socket(sock, map)
  227.             self.socket.setblocking(0)
  228.             self.connected = True
  229.             
  230.             try:
  231.                 self.addr = sock.getpeername()
  232.             except socket.error:
  233.                 pass
  234.             except:
  235.                 None<EXCEPTION MATCH>socket.error
  236.             
  237.  
  238.         None<EXCEPTION MATCH>socket.error
  239.         self.socket = None
  240.  
  241.     
  242.     def __repr__(self):
  243.         status = [
  244.             self.__class__.__module__ + '.' + self.__class__.__name__]
  245.         if self.accepting and self.addr:
  246.             status.append('listening')
  247.         elif self.connected:
  248.             status.append('connected')
  249.         
  250.         if self.addr is not None:
  251.             
  252.             try:
  253.                 status.append('%s:%d' % self.addr)
  254.             except TypeError:
  255.                 status.append(repr(self.addr))
  256.             except:
  257.                 None<EXCEPTION MATCH>TypeError
  258.             
  259.  
  260.         None<EXCEPTION MATCH>TypeError
  261.         return '<%s at %#x>' % (' '.join(status), id(self))
  262.  
  263.     
  264.     def add_channel(self, map = None):
  265.         if map is None:
  266.             map = self._map
  267.         
  268.         map[self._fileno] = self
  269.  
  270.     
  271.     def del_channel(self, map = None):
  272.         fd = self._fileno
  273.         if map is None:
  274.             map = self._map
  275.         
  276.         if map.has_key(fd):
  277.             del map[fd]
  278.         
  279.         self._fileno = None
  280.  
  281.     
  282.     def create_socket(self, family, type):
  283.         self.family_and_type = (family, type)
  284.         self.socket = socket.socket(family, type)
  285.         self.socket.setblocking(0)
  286.         self._fileno = self.socket.fileno()
  287.         self.add_channel()
  288.  
  289.     
  290.     def set_socket(self, sock, map = None):
  291.         self.socket = sock
  292.         self._fileno = sock.fileno()
  293.         self.add_channel(map)
  294.  
  295.     
  296.     def set_reuse_addr(self):
  297.         
  298.         try:
  299.             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) | 1)
  300.         except socket.error:
  301.             pass
  302.  
  303.  
  304.     
  305.     def readable(self):
  306.         return True
  307.  
  308.     
  309.     def writable(self):
  310.         return True
  311.  
  312.     
  313.     def listen(self, num):
  314.         self.accepting = True
  315.         if os.name == 'nt' and num > 5:
  316.             num = 1
  317.         
  318.         return self.socket.listen(num)
  319.  
  320.     
  321.     def bind(self, addr):
  322.         self.addr = addr
  323.         return self.socket.bind(addr)
  324.  
  325.     
  326.     def connect(self, address):
  327.         self.connected = False
  328.         err = self.socket.connect_ex(address)
  329.         if err in (EINPROGRESS, EALREADY, EWOULDBLOCK):
  330.             return None
  331.         
  332.         if err in (0, EISCONN):
  333.             self.addr = address
  334.             self.connected = True
  335.             self.handle_connect()
  336.         else:
  337.             raise socket.error, (err, errorcode[err])
  338.  
  339.     
  340.     def accept(self):
  341.         
  342.         try:
  343.             (conn, addr) = self.socket.accept()
  344.             return (conn, addr)
  345.         except socket.error:
  346.             why = None
  347.             if why[0] == EWOULDBLOCK:
  348.                 pass
  349.             else:
  350.                 raise 
  351.         except:
  352.             why[0] == EWOULDBLOCK
  353.  
  354.  
  355.     
  356.     def send(self, data):
  357.         
  358.         try:
  359.             result = self.socket.send(data)
  360.             return result
  361.         except socket.error:
  362.             why = None
  363.             if why[0] == EWOULDBLOCK:
  364.                 return 0
  365.             else:
  366.                 raise 
  367.             return 0
  368.  
  369.  
  370.     
  371.     def recv(self, buffer_size):
  372.         
  373.         try:
  374.             data = self.socket.recv(buffer_size)
  375.             if not data:
  376.                 self.handle_close()
  377.                 return ''
  378.             else:
  379.                 return data
  380.         except socket.error:
  381.             why = None
  382.             if why[0] in [
  383.                 ECONNRESET,
  384.                 ENOTCONN,
  385.                 ESHUTDOWN]:
  386.                 self.handle_close()
  387.                 return ''
  388.             else:
  389.                 raise 
  390.         except:
  391.             why[0] in [
  392.                 ECONNRESET,
  393.                 ENOTCONN,
  394.                 ESHUTDOWN]
  395.  
  396.  
  397.     
  398.     def close(self):
  399.         self.del_channel()
  400.         self.socket.close()
  401.  
  402.     
  403.     def __getattr__(self, attr):
  404.         return getattr(self.socket, attr)
  405.  
  406.     
  407.     def log(self, message):
  408.         sys.stderr.write('log: %s\n' % str(message))
  409.  
  410.     
  411.     def log_info(self, message, type = 'info'):
  412.         if __debug__ or type != 'info':
  413.             print '%s: %s' % (type, message)
  414.         
  415.  
  416.     
  417.     def handle_read_event(self):
  418.         if self.accepting:
  419.             if not self.connected:
  420.                 self.connected = True
  421.             
  422.             self.handle_accept()
  423.         elif not self.connected:
  424.             self.handle_connect()
  425.             self.connected = True
  426.             self.handle_read()
  427.         else:
  428.             self.handle_read()
  429.  
  430.     
  431.     def handle_write_event(self):
  432.         if not self.connected:
  433.             self.handle_connect()
  434.             self.connected = True
  435.         
  436.         self.handle_write()
  437.  
  438.     
  439.     def handle_expt_event(self):
  440.         self.handle_expt()
  441.  
  442.     
  443.     def handle_error(self):
  444.         (nil, t, v, tbinfo) = compact_traceback()
  445.         
  446.         try:
  447.             self_repr = repr(self)
  448.         except:
  449.             self_repr = '<__repr__(self) failed for object at %0x>' % id(self)
  450.  
  451.         self.log_info('uncaptured python exception, closing channel %s (%s:%s %s)' % (self_repr, t, v, tbinfo), 'error')
  452.         self.close()
  453.  
  454.     
  455.     def handle_expt(self):
  456.         self.log_info('unhandled exception', 'warning')
  457.  
  458.     
  459.     def handle_read(self):
  460.         self.log_info('unhandled read event', 'warning')
  461.  
  462.     
  463.     def handle_write(self):
  464.         self.log_info('unhandled write event', 'warning')
  465.  
  466.     
  467.     def handle_connect(self):
  468.         self.log_info('unhandled connect event', 'warning')
  469.  
  470.     
  471.     def handle_accept(self):
  472.         self.log_info('unhandled accept event', 'warning')
  473.  
  474.     
  475.     def handle_close(self):
  476.         self.log_info('unhandled close event', 'warning')
  477.         self.close()
  478.  
  479.  
  480.  
  481. class dispatcher_with_send(dispatcher):
  482.     
  483.     def __init__(self, sock = None, map = None):
  484.         dispatcher.__init__(self, sock, map)
  485.         self.out_buffer = ''
  486.  
  487.     
  488.     def initiate_send(self):
  489.         num_sent = 0
  490.         num_sent = dispatcher.send(self, self.out_buffer[:512])
  491.         self.out_buffer = self.out_buffer[num_sent:]
  492.  
  493.     
  494.     def handle_write(self):
  495.         self.initiate_send()
  496.  
  497.     
  498.     def writable(self):
  499.         if not not (self.connected):
  500.             pass
  501.         return len(self.out_buffer)
  502.  
  503.     
  504.     def send(self, data):
  505.         if self.debug:
  506.             self.log_info('sending %s' % repr(data))
  507.         
  508.         self.out_buffer = self.out_buffer + data
  509.         self.initiate_send()
  510.  
  511.  
  512.  
  513. def compact_traceback():
  514.     (t, v, tb) = sys.exc_info()
  515.     tbinfo = []
  516.     if not tb:
  517.         raise AssertionError
  518.     while tb:
  519.         tbinfo.append((tb.tb_frame.f_code.co_filename, tb.tb_frame.f_code.co_name, str(tb.tb_lineno)))
  520.         tb = tb.tb_next
  521.     del tb
  522.     (file, function, line) = tbinfo[-1]
  523.     info = []([ '[%s|%s|%s]' % x for x in tbinfo ])
  524.     return ((file, function, line), t, v, info)
  525.  
  526.  
  527. def close_all(map = None):
  528.     if map is None:
  529.         map = socket_map
  530.     
  531.     for x in map.values():
  532.         x.socket.close()
  533.     
  534.     map.clear()
  535.  
  536. if os.name == 'posix':
  537.     import fcntl
  538.     
  539.     class file_wrapper:
  540.         
  541.         def __init__(self, fd):
  542.             self.fd = fd
  543.  
  544.         
  545.         def recv(self, *args):
  546.             return os.read(self.fd, *args)
  547.  
  548.         
  549.         def send(self, *args):
  550.             return os.write(self.fd, *args)
  551.  
  552.         read = recv
  553.         write = send
  554.         
  555.         def close(self):
  556.             os.close(self.fd)
  557.  
  558.         
  559.         def fileno(self):
  560.             return self.fd
  561.  
  562.  
  563.     
  564.     class file_dispatcher(dispatcher):
  565.         
  566.         def __init__(self, fd, map = None):
  567.             dispatcher.__init__(self, None, map)
  568.             self.connected = True
  569.             self.set_file(fd)
  570.             flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0)
  571.             flags = flags | os.O_NONBLOCK
  572.             fcntl.fcntl(fd, fcntl.F_SETFL, flags)
  573.  
  574.         
  575.         def set_file(self, fd):
  576.             self._fileno = fd
  577.             self.socket = file_wrapper(fd)
  578.             self.add_channel()
  579.  
  580.  
  581.  
  582.